package com.example.myapplication;

import androidx.appcompat.app.AppCompatActivity;
import androidx.cardview.widget.CardView;

import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.View;
import android.widget.CompoundButton;
import android.widget.TextView;
import android.widget.Toast;

import com.example.myapplication.api.ApiService;
import com.example.myapplication.model.LightStatusResponse;
import com.example.myapplication.model.RpcRequest;
import com.example.myapplication.model.RpcResponse;
import com.example.myapplication.model.TelemetryData;
import com.example.myapplication.model.TelemetryResponse;
import com.example.myapplication.model.TemperatureData;
import com.example.myapplication.network.RetrofitClient;
import com.google.android.material.switchmaterial.SwitchMaterial;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Random;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

public class GreenhouseMainActivity extends AppCompatActivity {

    private static final String TAG = "GreenhouseMainActivity";

    // 设备ID - 从云平台API URL中提取
    private static final String DEVICE_ID = "3f0164f0-564a-11f0-a3b6-7fac07ef3d62";
    private static final String ENTITY_TYPE = "DEVICE";

    // RPC设备ID - 用于设备控制
    private static final String RPC_DEVICE_ID = "534dd0a0-57ae-11f0-a3b6-7fac07ef3d62";

    // 加湿器设备ID - 用于加湿器控制
    private static final String HUMIDIFIER_DEVICE_ID = "e476c6d0-5bab-11f0-a3b6-7fac07ef3d62";

    // 报警器设备ID - 用于报警器控制
    private static final String ALARM_DEVICE_ID = "445662e0-5bac-11f0-a3b6-7fac07ef3d62";

    // 风扇设备ID - 用于风扇控制
    private static final String FAN_DEVICE_ID = "0bd42380-5bac-11f0-a3b6-7fac07ef3d62";

    // 光照传感器设备ID - 用于获取光照数据
    private static final String LIGHT_SENSOR_DEVICE_ID = "86e7aea0-5ba4-11f0-a3b6-7fac07ef3d62";

    // 湿度传感器设备ID - 用于获取湿度数据
    private static final String HUMIDITY_SENSOR_DEVICE_ID = "60b2cc60-5ba4-11f0-a3b6-7fac07ef3d62";

    // 人体红外传感器设备ID - 用于获取人体检测数据
    private static final String HUMAN_DETECTION_SENSOR_DEVICE_ID = "abeac7a0-5ba4-11f0-a3b6-7fac07ef3d62";

    // 遥测数据访问令牌
    private static final String TELEMETRY_ACCESS_TOKEN = "01o5rfVyDcwA5SVEMIVA";

    // 加湿器遥测数据访问令牌
    private static final String HUMIDIFIER_TELEMETRY_ACCESS_TOKEN = "VZdP3NOovoUvGt0Uf12v";

    // 报警器遥测数据访问令牌
    private static final String ALARM_TELEMETRY_ACCESS_TOKEN = "uxi2sqiNX7OaN4DSK9qm";

    // 风扇遥测数据访问令牌
    private static final String FAN_TELEMETRY_ACCESS_TOKEN = "dboLAEUmgesFKD6QxIG2";

    // 自动刷新间隔（毫秒）
    private static final long AUTO_REFRESH_INTERVAL = 3000; // 3秒

    // 光照阈值
    private static final double LIGHT_THRESHOLD = 600.0; // 600 Lux

    // 温度阈值
    private static final double TEMPERATURE_THRESHOLD = 25.0; // 25度

    // 湿度阈值
    private static final double HUMIDITY_THRESHOLD = 50.0; // 50%

    // 人体检测阈值
    private static final double HUMAN_DETECTION_THRESHOLD = 5.0; // 5人

    // 传感器数据显示
    private TextView tvLightValue, tvHumidityValue, tvTemperatureValue, tvHumanDetectionValue;
    private TextView tvLastUpdate, tvUserName, tvModeStatus;

    // 设备控制开关
    private SwitchMaterial switchLight, switchHumidifier, switchFan, switchAlarm, switchAutoMode;

    // 卡片视图
    private CardView cardSensorData, cardDeviceControl;

    // 模拟数据
    private Random random = new Random();
    private String currentUser;
    private boolean isCloudUser;
    private String userToken;

    // 网络服务
    private ApiService apiService;

    // 自动刷新处理器
    private Handler autoRefreshHandler;
    private Runnable autoRefreshRunnable;

    // 自动模式相关
    private boolean isAutoMode = true;  // 默认自动模式
    private double currentTemperature = 0.0;  // 当前温度
    private double currentHumidity = 0.0;  // 当前湿度
    private double currentHumanDetection = 0.0;  // 当前人体检测数量
    private double currentLightValue = 0.0;  // 当前光照值

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_greenhouse_main);
        
        // 获取用户信息
        currentUser = getIntent().getStringExtra("username");
        isCloudUser = getIntent().getBooleanExtra("isCloudUser", false);
        userToken = getIntent().getStringExtra("token");

        if (currentUser == null) {
            currentUser = "用户";
        }
        
        initViews();
        initNetworkComponents();
        setupSwitchListeners();
        updateModeDisplay();  // 初始化模式显示
        setupAutoRefresh();

        // 首次加载数据
        if (isCloudUser) {
            fetchTemperatureFromCloud();
            fetchLightSensorFromCloud();
            fetchHumiditySensorFromCloud();
            fetchHumanDetectionSensorFromCloud();
            fetchLightStatusFromCloud();
            fetchHumidifierStatusFromCloud();
            fetchAlarmStatusFromCloud();
            fetchFanStatusFromCloud();
        } else {
            updateSensorData();
        }
    }

    private void initNetworkComponents() {
        // 初始化网络服务
        apiService = RetrofitClient.getInstance(this).getApiService();
    }

    private void setupAutoRefresh() {
        // 初始化自动刷新处理器
        autoRefreshHandler = new Handler();
        autoRefreshRunnable = new Runnable() {
            @Override
            public void run() {
                if (isCloudUser) {
                    fetchTemperatureFromCloud();
                    fetchLightSensorFromCloud();
                    fetchHumiditySensorFromCloud();
                    fetchHumanDetectionSensorFromCloud();
                    fetchLightStatusFromCloud();
                    fetchHumidifierStatusFromCloud();
                    fetchAlarmStatusFromCloud();
                    fetchFanStatusFromCloud();
                } else {
                    updateSensorData();
                }

                // 自动模式下检查传感器数据并控制设备
                if (isAutoMode && isCloudUser) {
                    checkLightValueAndControlLamp();
                    checkTemperatureAndControlFan();
                    checkHumidityAndControlHumidifier();
                    checkHumanDetectionAndControlAlarm();
                }

                // 安排下次刷新
                autoRefreshHandler.postDelayed(this, AUTO_REFRESH_INTERVAL);
            }
        };

        // 启动自动刷新
        autoRefreshHandler.postDelayed(autoRefreshRunnable, AUTO_REFRESH_INTERVAL);
    }

    private void initViews() {
        // 用户信息
        tvUserName = findViewById(R.id.tvUserName);
        String userDisplayText = "欢迎, " + currentUser;
        if (isCloudUser) {
            userDisplayText += " (云平台用户)";
            // 显示token状态
            if (userToken != null && !userToken.isEmpty()) {
                userDisplayText += "\n🔐 Token已激活: " + userToken.substring(0, Math.min(15, userToken.length())) + "...";
            }
        }
        tvUserName.setText(userDisplayText);

        // 模式状态显示
        tvModeStatus = findViewById(R.id.tvModeStatus);
        
        // 传感器数据
        tvLightValue = findViewById(R.id.tvLightValue);
        tvHumidityValue = findViewById(R.id.tvHumidityValue);
        tvTemperatureValue = findViewById(R.id.tvTemperatureValue);
        tvHumanDetectionValue = findViewById(R.id.tvHumanDetectionValue);
        tvLastUpdate = findViewById(R.id.tvLastUpdate);
        
        // 设备控制开关
        switchLight = findViewById(R.id.switchLight);
        switchHumidifier = findViewById(R.id.switchHumidifier);
        switchFan = findViewById(R.id.switchFan);
        switchAlarm = findViewById(R.id.switchAlarm);
        switchAutoMode = findViewById(R.id.switchAutoMode);
        
        // 卡片视图
        cardSensorData = findViewById(R.id.cardSensorData);
        cardDeviceControl = findViewById(R.id.cardDeviceControl);
        
        // 设置卡片点击事件
        cardSensorData.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (isCloudUser) {
                    fetchTemperatureFromCloud();
                    fetchLightSensorFromCloud();
                    fetchHumiditySensorFromCloud();
                    fetchHumanDetectionSensorFromCloud();
                    fetchLightStatusFromCloud();
                    fetchHumidifierStatusFromCloud();
                    fetchAlarmStatusFromCloud();
                    fetchFanStatusFromCloud();
                    Toast.makeText(GreenhouseMainActivity.this, "🌐 正在从云平台刷新数据...", Toast.LENGTH_SHORT).show();
                } else {
                    updateSensorData();
                    Toast.makeText(GreenhouseMainActivity.this, "📊 传感器数据已刷新", Toast.LENGTH_SHORT).show();
                }
            }
        });

        // 设置设备控制卡片点击事件 - 显示token信息
        cardDeviceControl.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (isCloudUser && userToken != null) {
                    String tokenInfo = "🔐 当前Token信息:\n\n" +
                            "用户: " + currentUser + "\n" +
                            "Token: " + userToken.substring(0, Math.min(30, userToken.length())) + "...\n" +
                            "状态: ✅ 已激活\n" +
                            "存储: 💾 本地安全存储";
                    Toast.makeText(GreenhouseMainActivity.this, tokenInfo, Toast.LENGTH_LONG).show();
                } else {
                    Toast.makeText(GreenhouseMainActivity.this, "设备控制功能", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    private void setupSwitchListeners() {
        // 自动模式开关
        switchAutoMode.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                isAutoMode = isChecked;
                updateModeDisplay();

                String mode = isChecked ? "自动模式" : "手动模式";
                Toast.makeText(GreenhouseMainActivity.this, "🔄 已切换到" + mode, Toast.LENGTH_SHORT).show();

                Log.d(TAG, "模式切换: " + mode);
            }
        });

        // 灯泡控制
        setupLightSwitchListener();

        // 加湿器控制
        setupHumidifierSwitchListener();

        // 风扇控制
        setupFanSwitchListener();

        // 报警器控制
        setupAlarmSwitchListener();
    }

    /**
     * 从云平台获取温度数据
     */
    private void fetchTemperatureFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取遥测数据
        Call<TelemetryResponse> call = apiService.getTelemetryData(
                "Bearer " + userToken,
                ENTITY_TYPE,
                DEVICE_ID,
                false
        );

        call.enqueue(new Callback<TelemetryResponse>() {
            @Override
            public void onResponse(Call<TelemetryResponse> call, Response<TelemetryResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    TelemetryResponse telemetryResponse = response.body();
                    TemperatureData latestTemp = telemetryResponse.getLatestTemperature();

                    if (latestTemp != null) {
                        Log.d(TAG, "云平台温度数据: " + latestTemp.getValue() + "°C");

                        // 保存当前温度值
                        currentTemperature = latestTemp.getTemperatureValue();

                        // 更新温度显示
                        tvTemperatureValue.setText(latestTemp.getValue() + "°C");

                        // 更新时间
                        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
                        tvLastUpdate.setText("☁️ 云平台更新: " + sdf.format(new Date()));

                    } else {
                        Log.w(TAG, "云平台返回的温度数据为空");
                        updateSensorData(); // 回退到模拟数据
                    }
                } else {
                    Log.e(TAG, "获取云平台数据失败，响应码: " + response.code());
                    updateSensorData(); // 回退到模拟数据
                }
            }

            @Override
            public void onFailure(Call<TelemetryResponse> call, Throwable t) {
                Log.e(TAG, "云平台API调用失败", t);
                updateSensorData(); // 回退到模拟数据
            }
        });
    }

    /**
     * 从云平台获取光照传感器数据
     */
    private void fetchLightSensorFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取光照传感器数据
        Call<TelemetryResponse> call = apiService.getLightSensorData(
                "Bearer " + userToken,
                ENTITY_TYPE,
                LIGHT_SENSOR_DEVICE_ID,
                false
        );

        call.enqueue(new Callback<TelemetryResponse>() {
            @Override
            public void onResponse(Call<TelemetryResponse> call, Response<TelemetryResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    TelemetryResponse telemetryResponse = response.body();
                    TemperatureData latestLight = telemetryResponse.getLatestTemperature();

                    if (latestLight != null) {
                        Log.d(TAG, "云平台光照数据: " + latestLight.getValue() + " Lux");

                        // 保存当前光照值
                        currentLightValue = latestLight.getTemperatureValue();

                        // 更新光照显示
                        tvLightValue.setText(latestLight.getValue() + " Lux");

                        // 更新时间
                        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
                        tvLastUpdate.setText("☁️ 云平台更新: " + sdf.format(new Date()));

                    } else {
                        Log.w(TAG, "云平台返回的光照数据为空");
                        // 保持当前光照显示不变，或使用模拟数据
                        updateLightSensorDataOnly();
                    }
                } else {
                    Log.e(TAG, "获取云平台光照数据失败，响应码: " + response.code());
                    // 保持当前光照显示不变，或使用模拟数据
                    updateLightSensorDataOnly();
                }
            }

            @Override
            public void onFailure(Call<TelemetryResponse> call, Throwable t) {
                Log.e(TAG, "云平台光照API调用失败", t);
                // 保持当前光照显示不变，或使用模拟数据
                updateLightSensorDataOnly();
            }
        });
    }

    /**
     * 更新光照传感器数据（模拟）
     */
    private void updateLightSensorDataOnly() {
        int lightValue = 600 + random.nextInt(100); // 600-700 Lux
        tvLightValue.setText(lightValue + " Lux");
    }

    /**
     * 从云平台获取湿度传感器数据
     */
    private void fetchHumiditySensorFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取湿度传感器数据
        Call<TelemetryResponse> call = apiService.getHumiditySensorData(
                "Bearer " + userToken,
                ENTITY_TYPE,
                HUMIDITY_SENSOR_DEVICE_ID,
                false
        );

        call.enqueue(new Callback<TelemetryResponse>() {
            @Override
            public void onResponse(Call<TelemetryResponse> call, Response<TelemetryResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    TelemetryResponse telemetryResponse = response.body();
                    TemperatureData latestHumidity = telemetryResponse.getLatestTemperature();

                    if (latestHumidity != null) {
                        Log.d(TAG, "云平台湿度数据: " + latestHumidity.getValue() + "%");

                        // 保存当前湿度值
                        currentHumidity = latestHumidity.getTemperatureValue();

                        // 更新湿度显示
                        tvHumidityValue.setText(latestHumidity.getValue() + "%");

                        // 更新时间
                        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
                        tvLastUpdate.setText("☁️ 云平台更新: " + sdf.format(new Date()));

                    } else {
                        Log.w(TAG, "云平台返回的湿度数据为空");
                        // 保持当前湿度显示不变，或使用模拟数据
                        updateHumiditySensorDataOnly();
                    }
                } else {
                    Log.e(TAG, "获取云平台湿度数据失败，响应码: " + response.code());
                    // 保持当前湿度显示不变，或使用模拟数据
                    updateHumiditySensorDataOnly();
                }
            }

            @Override
            public void onFailure(Call<TelemetryResponse> call, Throwable t) {
                Log.e(TAG, "云平台湿度API调用失败", t);
                // 保持当前湿度显示不变，或使用模拟数据
                updateHumiditySensorDataOnly();
            }
        });
    }

    /**
     * 更新湿度传感器数据（模拟）
     */
    private void updateHumiditySensorDataOnly() {
        int humidity = 60 + random.nextInt(20); // 60-80%
        tvHumidityValue.setText(humidity + "%");
    }

    /**
     * 从云平台获取人体红外传感器数据
     */
    private void fetchHumanDetectionSensorFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取人体红外传感器数据
        Call<TelemetryResponse> call = apiService.getHumanDetectionSensorData(
                "Bearer " + userToken,
                ENTITY_TYPE,
                HUMAN_DETECTION_SENSOR_DEVICE_ID,
                false
        );

        call.enqueue(new Callback<TelemetryResponse>() {
            @Override
            public void onResponse(Call<TelemetryResponse> call, Response<TelemetryResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    TelemetryResponse telemetryResponse = response.body();
                    TemperatureData latestHumanDetection = telemetryResponse.getLatestTemperature();

                    if (latestHumanDetection != null) {
                        Log.d(TAG, "云平台人体检测数据: " + latestHumanDetection.getValue());

                        // 保存当前人体检测数量
                        currentHumanDetection = latestHumanDetection.getTemperatureValue();

                        // 更新人体检测显示
                        tvHumanDetectionValue.setText(latestHumanDetection.getValue());

                        // 更新时间
                        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
                        tvLastUpdate.setText("☁️ 云平台更新: " + sdf.format(new Date()));

                    } else {
                        Log.w(TAG, "云平台返回的人体检测数据为空");
                        // 保持当前人体检测显示不变，或使用模拟数据
                        updateHumanDetectionDataOnly();
                    }
                } else {
                    Log.e(TAG, "获取云平台人体检测数据失败，响应码: " + response.code());
                    // 保持当前人体检测显示不变，或使用模拟数据
                    updateHumanDetectionDataOnly();
                }
            }

            @Override
            public void onFailure(Call<TelemetryResponse> call, Throwable t) {
                Log.e(TAG, "云平台人体检测API调用失败", t);
                // 保持当前人体检测显示不变，或使用模拟数据
                updateHumanDetectionDataOnly();
            }
        });
    }

    /**
     * 更新人体检测数据（模拟）
     */
    private void updateHumanDetectionDataOnly() {
        int humanDetection = random.nextInt(10);    // 0-9 人数
        tvHumanDetectionValue.setText(String.valueOf(humanDetection));
    }

    /**
     * 更新其他传感器数据（模拟）- 仅用于本地模式
     */
    private void updateOtherSensorData() {
        int lightValue = 600 + random.nextInt(100); // 600-700 Lux
        int humidity = 60 + random.nextInt(20);     // 60-80%
        int humanDetection = random.nextInt(10);    // 0-9 人数

        tvLightValue.setText(lightValue + " Lux");
        tvHumidityValue.setText(humidity + "%");
        tvHumanDetectionValue.setText(String.valueOf(humanDetection));
    }

    /**
     * 通过云平台控制灯泡
     * @param isOn 灯泡状态：true=开启，false=关闭
     */
    private void controlLampViaCloud(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 创建RPC请求
        RpcRequest rpcRequest = RpcRequest.createLampRequest(isOn);
        String status = isOn ? "开启" : "关闭";

        Log.d(TAG, "发送灯泡控制命令: " + status);

        // 调用云平台RPC API（不等待响应）
        Call<RpcResponse> call = apiService.sendRpcCommand(
                "Bearer " + userToken,
                RPC_DEVICE_ID,
                rpcRequest
        );

        // 发送RPC命令，然后发送遥测数据
        call.enqueue(new Callback<RpcResponse>() {
            @Override
            public void onResponse(Call<RpcResponse> call, Response<RpcResponse> response) {
                Log.d(TAG, "灯泡RPC控制命令已发送: " + status);
                // RPC命令发送后，立即发送遥测数据
                sendTelemetryData(isOn);
            }

            @Override
            public void onFailure(Call<RpcResponse> call, Throwable t) {
                Log.d(TAG, "灯泡RPC控制命令已发送: " + status + " (网络状态未知)");
                // 即使RPC失败，也发送遥测数据
                sendTelemetryData(isOn);
            }
        });

        // 立即显示成功消息
        Toast.makeText(this, "✅ 灯泡已" + status + " (云平台)", Toast.LENGTH_SHORT).show();
    }

    /**
     * 发送遥测数据到云平台
     * @param isOn 灯泡状态：true=开启(1)，false=关闭(0)
     */
    private void sendTelemetryData(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化，无法发送遥测数据");
            return;
        }

        // 创建遥测数据
        TelemetryData telemetryData = TelemetryData.createLightTelemetry(isOn);
        String status = isOn ? "开启(1)" : "关闭(0)";

        Log.d(TAG, "发送遥测数据: " + status);

        // 调用遥测数据上报API
        Call<Void> telemetryCall = apiService.sendTelemetryData(
                TELEMETRY_ACCESS_TOKEN,
                telemetryData
        );

        telemetryCall.enqueue(new Callback<Void>() {
            @Override
            public void onResponse(Call<Void> call, Response<Void> response) {
                if (response.isSuccessful()) {
                    Log.d(TAG, "遥测数据发送成功: " + status);
                } else {
                    Log.w(TAG, "遥测数据发送失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<Void> call, Throwable t) {
                Log.w(TAG, "遥测数据发送失败", t);
            }
        });
    }

    /**
     * 从云平台获取灯光状态
     */
    private void fetchLightStatusFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取灯光状态
        Call<LightStatusResponse> call = apiService.getLightStatus(
                "Bearer " + userToken,
                ENTITY_TYPE,
                RPC_DEVICE_ID,  // 使用RPC设备ID获取灯光状态
                false
        );

        call.enqueue(new Callback<LightStatusResponse>() {
            @Override
            public void onResponse(Call<LightStatusResponse> call, Response<LightStatusResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    LightStatusResponse lightResponse = response.body();
                    Boolean lightState = lightResponse.getLatestLightState();

                    if (lightState != null) {
                        Log.d(TAG, "云平台灯光状态: " + (lightState ? "开启(1)" : "关闭(0)"));

                        // 同步开关状态（不触发事件）
                        updateLightSwitchState(lightState);

                    } else {
                        Log.w(TAG, "云平台返回的灯光状态数据为空或无效");
                    }
                } else {
                    Log.e(TAG, "获取云平台灯光状态失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<LightStatusResponse> call, Throwable t) {
                Log.e(TAG, "云平台灯光状态API调用失败", t);
            }
        });
    }

    /**
     * 更新灯光开关状态（不触发事件）
     * @param isOn 灯光状态：true=开启，false=关闭
     */
    private void updateLightSwitchState(boolean isOn) {
        // 检查当前开关状态，只有不同时才更新
        if (switchLight.isChecked() != isOn) {
            // 临时移除监听器，避免触发控制命令
            switchLight.setOnCheckedChangeListener(null);

            // 更新开关状态
            switchLight.setChecked(isOn);

            // 重新设置监听器
            setupLightSwitchListener();

            Log.d(TAG, "灯光开关状态已同步: " + (isOn ? "开启" : "关闭"));
        }
    }

    /**
     * 设置灯光开关监听器
     */
    private void setupLightSwitchListener() {
        switchLight.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if (isCloudUser && userToken != null) {
                    // 云平台用户：发送RPC命令控制真实设备
                    controlLampViaCloud(isChecked);
                } else {
                    // 本地用户：显示模拟控制结果
                    String status = isChecked ? "开启" : "关闭";
                    Toast.makeText(GreenhouseMainActivity.this, "💡 灯泡已" + status + " (模拟)", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    /**
     * 检查光照并自动控制灯光
     */
    private void checkLightValueAndControlLamp() {
        if (!isAutoMode || !isCloudUser) {
            return;
        }

        // 检查光照是否低于阈值（需要补光）
        if (currentLightValue < LIGHT_THRESHOLD) {
            // 检查灯光是否已经开启，避免重复控制
            if (!switchLight.isChecked()) {
                Log.d(TAG, "自动模式：光照 " + currentLightValue + " Lux 低于阈值 " + LIGHT_THRESHOLD + " Lux，自动开启灯光补光");

                // 模拟手动点击开关开启灯光
                switchLight.setChecked(true);

                // 显示自动控制提示
                Toast.makeText(this, "🤖 自动模式：光照不足(" + (int)currentLightValue + " Lux)，已自动开启灯光补光", Toast.LENGTH_LONG).show();
            }
        }
    }

    /**
     * 通过云平台控制风扇
     * @param isOn 风扇状态：true=开启，false=关闭
     */
    private void controlFanViaCloud(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 创建RPC请求
        RpcRequest rpcRequest = RpcRequest.createFanRequest(isOn);
        String status = isOn ? "开启" : "关闭";

        Log.d(TAG, "发送风扇控制命令: " + status);

        // 调用云平台RPC API（不等待响应）
        Call<RpcResponse> call = apiService.sendRpcCommand(
                "Bearer " + userToken,
                FAN_DEVICE_ID,
                rpcRequest
        );

        // 发送RPC命令，然后发送遥测数据
        call.enqueue(new Callback<RpcResponse>() {
            @Override
            public void onResponse(Call<RpcResponse> call, Response<RpcResponse> response) {
                Log.d(TAG, "风扇RPC控制命令已发送: " + status);
                // RPC命令发送后，立即发送遥测数据
                sendFanTelemetryData(isOn);
            }

            @Override
            public void onFailure(Call<RpcResponse> call, Throwable t) {
                Log.d(TAG, "风扇RPC控制命令已发送: " + status + " (网络状态未知)");
                // 即使RPC失败，也发送遥测数据
                sendFanTelemetryData(isOn);
            }
        });

        // 立即显示成功消息
        Toast.makeText(this, "✅ 风扇已" + status + " (云平台)", Toast.LENGTH_SHORT).show();
    }

    /**
     * 发送风扇遥测数据到云平台
     * @param isOn 风扇状态：true=开启(1)，false=关闭(0)
     */
    private void sendFanTelemetryData(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化，无法发送风扇遥测数据");
            return;
        }

        // 创建遥测数据
        TelemetryData telemetryData = TelemetryData.createFanTelemetry(isOn);
        String status = isOn ? "开启(1)" : "关闭(0)";

        Log.d(TAG, "发送风扇遥测数据: " + status);

        // 调用遥测数据上报API
        Call<Void> telemetryCall = apiService.sendFanTelemetryData(
                FAN_TELEMETRY_ACCESS_TOKEN,
                telemetryData
        );

        telemetryCall.enqueue(new Callback<Void>() {
            @Override
            public void onResponse(Call<Void> call, Response<Void> response) {
                if (response.isSuccessful()) {
                    Log.d(TAG, "风扇遥测数据发送成功: " + status);
                } else {
                    Log.w(TAG, "风扇遥测数据发送失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<Void> call, Throwable t) {
                Log.w(TAG, "风扇遥测数据发送失败", t);
            }
        });
    }

    /**
     * 从云平台获取风扇状态
     */
    private void fetchFanStatusFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取风扇状态
        Call<LightStatusResponse> call = apiService.getFanStatus(
                "Bearer " + userToken,
                ENTITY_TYPE,
                FAN_DEVICE_ID,
                false
        );

        call.enqueue(new Callback<LightStatusResponse>() {
            @Override
            public void onResponse(Call<LightStatusResponse> call, Response<LightStatusResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    LightStatusResponse fanResponse = response.body();
                    Boolean fanState = fanResponse.getLatestLightState();

                    if (fanState != null) {
                        Log.d(TAG, "云平台风扇状态: " + (fanState ? "开启(1)" : "关闭(0)"));

                        // 同步开关状态（不触发事件）
                        updateFanSwitchState(fanState);

                    } else {
                        Log.w(TAG, "云平台返回的风扇状态数据为空或无效");
                    }
                } else {
                    Log.e(TAG, "获取云平台风扇状态失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<LightStatusResponse> call, Throwable t) {
                Log.e(TAG, "云平台风扇状态API调用失败", t);
            }
        });
    }

    /**
     * 更新风扇开关状态（不触发事件）
     * @param isOn 风扇状态：true=开启，false=关闭
     */
    private void updateFanSwitchState(boolean isOn) {
        // 检查当前开关状态，只有不同时才更新
        if (switchFan.isChecked() != isOn) {
            // 临时移除监听器，避免触发控制命令
            switchFan.setOnCheckedChangeListener(null);

            // 更新开关状态
            switchFan.setChecked(isOn);

            // 重新设置监听器
            setupFanSwitchListener();

            Log.d(TAG, "风扇开关状态已同步: " + (isOn ? "开启" : "关闭"));
        }
    }

    /**
     * 设置风扇开关监听器
     */
    private void setupFanSwitchListener() {
        switchFan.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if (isCloudUser && userToken != null) {
                    // 云平台用户：发送RPC命令控制真实设备
                    controlFanViaCloud(isChecked);
                } else {
                    // 本地用户：显示模拟控制结果
                    String status = isChecked ? "开启" : "关闭";
                    Toast.makeText(GreenhouseMainActivity.this, "🌀 风扇已" + status + " (模拟)", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    /**
     * 检查温度并自动控制风扇
     */
    private void checkTemperatureAndControlFan() {
        if (!isAutoMode || !isCloudUser) {
            return;
        }

        // 检查温度是否高于阈值
        if (currentTemperature > TEMPERATURE_THRESHOLD) {
            // 检查风扇是否已经开启，避免重复控制
            if (!switchFan.isChecked()) {
                Log.d(TAG, "自动模式：温度 " + currentTemperature + "°C 高于阈值 " + TEMPERATURE_THRESHOLD + "°C，自动开启风扇");

                // 模拟手动点击开关开启风扇
                switchFan.setChecked(true);

                // 显示自动控制提示
                Toast.makeText(this, "🤖 自动模式：温度过高(" + currentTemperature + "°C)，已自动开启风扇", Toast.LENGTH_LONG).show();
            }
        }
    }

    /**
     * 通过云平台控制加湿器
     * @param isOn 加湿器状态：true=开启，false=关闭
     */
    private void controlHumidifierViaCloud(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 创建RPC请求
        RpcRequest rpcRequest = RpcRequest.createHumidifierRequest(isOn);
        String status = isOn ? "开启" : "关闭";

        Log.d(TAG, "发送加湿器控制命令: " + status);

        // 调用云平台RPC API（不等待响应）
        Call<RpcResponse> call = apiService.sendRpcCommand(
                "Bearer " + userToken,
                HUMIDIFIER_DEVICE_ID,
                rpcRequest
        );

        // 发送RPC命令，然后发送遥测数据
        call.enqueue(new Callback<RpcResponse>() {
            @Override
            public void onResponse(Call<RpcResponse> call, Response<RpcResponse> response) {
                Log.d(TAG, "加湿器RPC控制命令已发送: " + status);
                // RPC命令发送后，立即发送遥测数据
                sendHumidifierTelemetryData(isOn);
            }

            @Override
            public void onFailure(Call<RpcResponse> call, Throwable t) {
                Log.d(TAG, "加湿器RPC控制命令已发送: " + status + " (网络状态未知)");
                // 即使RPC失败，也发送遥测数据
                sendHumidifierTelemetryData(isOn);
            }
        });

        // 立即显示成功消息
        Toast.makeText(this, "✅ 加湿器已" + status + " (云平台)", Toast.LENGTH_SHORT).show();
    }

    /**
     * 发送加湿器遥测数据到云平台
     * @param isOn 加湿器状态：true=开启(1)，false=关闭(0)
     */
    private void sendHumidifierTelemetryData(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化，无法发送加湿器遥测数据");
            return;
        }

        // 创建遥测数据
        TelemetryData telemetryData = TelemetryData.createHumidifierTelemetry(isOn);
        String status = isOn ? "开启(1)" : "关闭(0)";

        Log.d(TAG, "发送加湿器遥测数据: " + status);

        // 调用遥测数据上报API
        Call<Void> telemetryCall = apiService.sendHumidifierTelemetryData(
                HUMIDIFIER_TELEMETRY_ACCESS_TOKEN,
                telemetryData
        );

        telemetryCall.enqueue(new Callback<Void>() {
            @Override
            public void onResponse(Call<Void> call, Response<Void> response) {
                if (response.isSuccessful()) {
                    Log.d(TAG, "加湿器遥测数据发送成功: " + status);
                } else {
                    Log.w(TAG, "加湿器遥测数据发送失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<Void> call, Throwable t) {
                Log.w(TAG, "加湿器遥测数据发送失败", t);
            }
        });
    }

    /**
     * 从云平台获取加湿器状态
     */
    private void fetchHumidifierStatusFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取加湿器状态
        Call<LightStatusResponse> call = apiService.getHumidifierStatus(
                "Bearer " + userToken,
                ENTITY_TYPE,
                HUMIDIFIER_DEVICE_ID,
                false
        );

        call.enqueue(new Callback<LightStatusResponse>() {
            @Override
            public void onResponse(Call<LightStatusResponse> call, Response<LightStatusResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    LightStatusResponse humidifierResponse = response.body();
                    Boolean humidifierState = humidifierResponse.getLatestLightState();

                    if (humidifierState != null) {
                        Log.d(TAG, "云平台加湿器状态: " + (humidifierState ? "开启(1)" : "关闭(0)"));

                        // 同步开关状态（不触发事件）
                        updateHumidifierSwitchState(humidifierState);

                    } else {
                        Log.w(TAG, "云平台返回的加湿器状态数据为空或无效");
                    }
                } else {
                    Log.e(TAG, "获取云平台加湿器状态失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<LightStatusResponse> call, Throwable t) {
                Log.e(TAG, "云平台加湿器状态API调用失败", t);
            }
        });
    }

    /**
     * 更新加湿器开关状态（不触发事件）
     * @param isOn 加湿器状态：true=开启，false=关闭
     */
    private void updateHumidifierSwitchState(boolean isOn) {
        // 检查当前开关状态，只有不同时才更新
        if (switchHumidifier.isChecked() != isOn) {
            // 临时移除监听器，避免触发控制命令
            switchHumidifier.setOnCheckedChangeListener(null);

            // 更新开关状态
            switchHumidifier.setChecked(isOn);

            // 重新设置监听器
            setupHumidifierSwitchListener();

            Log.d(TAG, "加湿器开关状态已同步: " + (isOn ? "开启" : "关闭"));
        }
    }

    /**
     * 设置加湿器开关监听器
     */
    private void setupHumidifierSwitchListener() {
        switchHumidifier.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if (isCloudUser && userToken != null) {
                    // 云平台用户：发送RPC命令控制真实设备
                    controlHumidifierViaCloud(isChecked);
                } else {
                    // 本地用户：显示模拟控制结果
                    String status = isChecked ? "开启" : "关闭";
                    Toast.makeText(GreenhouseMainActivity.this, "💧 加湿器已" + status + " (模拟)", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    /**
     * 检查湿度并自动控制加湿器
     */
    private void checkHumidityAndControlHumidifier() {
        if (!isAutoMode || !isCloudUser) {
            return;
        }

        // 检查湿度是否低于阈值
        if (currentHumidity < HUMIDITY_THRESHOLD) {
            // 检查加湿器是否已经开启，避免重复控制
            if (!switchHumidifier.isChecked()) {
                Log.d(TAG, "自动模式：湿度 " + currentHumidity + "% 低于阈值 " + HUMIDITY_THRESHOLD + "%，自动开启加湿器");

                // 模拟手动点击开关开启加湿器
                switchHumidifier.setChecked(true);

                // 显示自动控制提示
                Toast.makeText(this, "🤖 自动模式：湿度过低(" + currentHumidity + "%)，已自动开启加湿器", Toast.LENGTH_LONG).show();
            }
        }
    }

    /**
     * 通过云平台控制报警器
     * @param isOn 报警器状态：true=开启，false=关闭
     */
    private void controlAlarmViaCloud(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 创建RPC请求
        RpcRequest rpcRequest = RpcRequest.createAlarmRequest(isOn);
        String status = isOn ? "开启" : "关闭";

        Log.d(TAG, "发送报警器控制命令: " + status);

        // 调用云平台RPC API（不等待响应）
        Call<RpcResponse> call = apiService.sendRpcCommand(
                "Bearer " + userToken,
                ALARM_DEVICE_ID,
                rpcRequest
        );

        // 发送RPC命令，然后发送遥测数据
        call.enqueue(new Callback<RpcResponse>() {
            @Override
            public void onResponse(Call<RpcResponse> call, Response<RpcResponse> response) {
                Log.d(TAG, "报警器RPC控制命令已发送: " + status);
                // RPC命令发送后，立即发送遥测数据
                sendAlarmTelemetryData(isOn);
            }

            @Override
            public void onFailure(Call<RpcResponse> call, Throwable t) {
                Log.d(TAG, "报警器RPC控制命令已发送: " + status + " (网络状态未知)");
                // 即使RPC失败，也发送遥测数据
                sendAlarmTelemetryData(isOn);
            }
        });

        // 立即显示成功消息
        Toast.makeText(this, "✅ 报警器已" + status + " (云平台)", Toast.LENGTH_SHORT).show();
    }

    /**
     * 发送报警器遥测数据到云平台
     * @param isOn 报警器状态：true=开启(1)，false=关闭(0)
     */
    private void sendAlarmTelemetryData(boolean isOn) {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化，无法发送报警器遥测数据");
            return;
        }

        // 创建遥测数据
        TelemetryData telemetryData = TelemetryData.createAlarmTelemetry(isOn);
        String status = isOn ? "开启(1)" : "关闭(0)";

        Log.d(TAG, "发送报警器遥测数据: " + status);

        // 调用遥测数据上报API
        Call<Void> telemetryCall = apiService.sendAlarmTelemetryData(
                ALARM_TELEMETRY_ACCESS_TOKEN,
                telemetryData
        );

        telemetryCall.enqueue(new Callback<Void>() {
            @Override
            public void onResponse(Call<Void> call, Response<Void> response) {
                if (response.isSuccessful()) {
                    Log.d(TAG, "报警器遥测数据发送成功: " + status);
                } else {
                    Log.w(TAG, "报警器遥测数据发送失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<Void> call, Throwable t) {
                Log.w(TAG, "报警器遥测数据发送失败", t);
            }
        });
    }

    /**
     * 从云平台获取报警器状态
     */
    private void fetchAlarmStatusFromCloud() {
        if (apiService == null) {
            Log.e(TAG, "ApiService未初始化");
            return;
        }

        // 调用云平台API获取报警器状态
        Call<LightStatusResponse> call = apiService.getAlarmStatus(
                "Bearer " + userToken,
                ENTITY_TYPE,
                ALARM_DEVICE_ID,
                false
        );

        call.enqueue(new Callback<LightStatusResponse>() {
            @Override
            public void onResponse(Call<LightStatusResponse> call, Response<LightStatusResponse> response) {
                if (response.isSuccessful() && response.body() != null) {
                    LightStatusResponse alarmResponse = response.body();
                    Boolean alarmState = alarmResponse.getLatestLightState();

                    if (alarmState != null) {
                        Log.d(TAG, "云平台报警器状态: " + (alarmState ? "开启(1)" : "关闭(0)"));

                        // 同步开关状态（不触发事件）
                        updateAlarmSwitchState(alarmState);

                    } else {
                        Log.w(TAG, "云平台返回的报警器状态数据为空或无效");
                    }
                } else {
                    Log.e(TAG, "获取云平台报警器状态失败，响应码: " + response.code());
                }
            }

            @Override
            public void onFailure(Call<LightStatusResponse> call, Throwable t) {
                Log.e(TAG, "云平台报警器状态API调用失败", t);
            }
        });
    }

    /**
     * 更新报警器开关状态（不触发事件）
     * @param isOn 报警器状态：true=开启，false=关闭
     */
    private void updateAlarmSwitchState(boolean isOn) {
        // 检查当前开关状态，只有不同时才更新
        if (switchAlarm.isChecked() != isOn) {
            // 临时移除监听器，避免触发控制命令
            switchAlarm.setOnCheckedChangeListener(null);

            // 更新开关状态
            switchAlarm.setChecked(isOn);

            // 重新设置监听器
            setupAlarmSwitchListener();

            Log.d(TAG, "报警器开关状态已同步: " + (isOn ? "开启" : "关闭"));
        }
    }

    /**
     * 设置报警器开关监听器
     */
    private void setupAlarmSwitchListener() {
        switchAlarm.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if (isCloudUser && userToken != null) {
                    // 云平台用户：发送RPC命令控制真实设备
                    controlAlarmViaCloud(isChecked);
                } else {
                    // 本地用户：显示模拟控制结果
                    String status = isChecked ? "开启" : "关闭";
                    Toast.makeText(GreenhouseMainActivity.this, "🚨 报警器已" + status + " (模拟)", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    /**
     * 检查人体检测并自动控制报警器
     */
    private void checkHumanDetectionAndControlAlarm() {
        if (!isAutoMode || !isCloudUser) {
            return;
        }

        // 检查人体检测数量是否高于阈值
        if (currentHumanDetection > HUMAN_DETECTION_THRESHOLD) {
            // 检查报警器是否已经开启，避免重复控制
            if (!switchAlarm.isChecked()) {
                Log.d(TAG, "自动模式：人体检测数量 " + currentHumanDetection + " 高于阈值 " + HUMAN_DETECTION_THRESHOLD + "，自动开启报警器");

                // 模拟手动点击开关开启报警器
                switchAlarm.setChecked(true);

                // 显示自动控制提示
                Toast.makeText(this, "🤖 自动模式：检测到过多人员(" + (int)currentHumanDetection + "人)，已自动开启报警器", Toast.LENGTH_LONG).show();
            }
        }
    }

    /**
     * 更新模式显示
     */
    private void updateModeDisplay() {
        if (tvModeStatus != null) {
            String modeText = isAutoMode ? "自动模式" : "手动模式";
            tvModeStatus.setText(modeText);

            // 根据模式改变文字颜色
            int colorRes = isAutoMode ? R.color.greenhouse_secondary : R.color.secondary_text;
            tvModeStatus.setTextColor(getResources().getColor(colorRes, null));
        }
    }

    /**
     * 更新传感器数据（模拟数据）
     */
    private void updateSensorData() {
        // 模拟传感器数据
        int lightValue = 600 + random.nextInt(100); // 600-700 Lux
        int humidity = 60 + random.nextInt(20);     // 60-80%
        int temperature = 20 + random.nextInt(15);  // 20-35°C
        int humanDetection = random.nextInt(10);    // 0-9 人数

        // 更新显示
        tvLightValue.setText(lightValue + " Lux");
        tvHumidityValue.setText(humidity + "%");
        tvTemperatureValue.setText(temperature + "°C");
        tvHumanDetectionValue.setText(String.valueOf(humanDetection));

        // 更新时间
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
        tvLastUpdate.setText("📱 本地更新: " + sdf.format(new Date()));
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 页面恢复时刷新数据
        if (isCloudUser) {
            fetchTemperatureFromCloud();
            fetchLightSensorFromCloud();
            fetchHumiditySensorFromCloud();
            fetchHumanDetectionSensorFromCloud();
            fetchLightStatusFromCloud();
            fetchHumidifierStatusFromCloud();
            fetchAlarmStatusFromCloud();
            fetchFanStatusFromCloud();
        } else {
            updateSensorData();
        }

        // 重新启动自动刷新
        if (autoRefreshHandler != null && autoRefreshRunnable != null) {
            autoRefreshHandler.postDelayed(autoRefreshRunnable, AUTO_REFRESH_INTERVAL);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 页面暂停时停止自动刷新
        if (autoRefreshHandler != null && autoRefreshRunnable != null) {
            autoRefreshHandler.removeCallbacks(autoRefreshRunnable);
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 页面销毁时清理资源
        if (autoRefreshHandler != null && autoRefreshRunnable != null) {
            autoRefreshHandler.removeCallbacks(autoRefreshRunnable);
        }
    }
}
